home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 21 / AACD 21.iso / AACD / Utilities / Ghostscript / src / gdevdcrd.c < prev    next >
Encoding:
C/C++ Source or Header  |  2001-01-01  |  5.4 KB  |  179 lines
  1. /* Copyright (C) 1999 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of AFPL Ghostscript.
  4.   
  5.   AFPL Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author or
  6.   distributor accepts any responsibility for the consequences of using it, or
  7.   for whether it serves any particular purpose or works at all, unless he or
  8.   she says so in writing.  Refer to the Aladdin Free Public License (the
  9.   "License") for full details.
  10.   
  11.   Every copy of AFPL Ghostscript must include a copy of the License, normally
  12.   in a plain ASCII text file named PUBLIC.  The License grants you the right
  13.   to copy, modify and redistribute AFPL Ghostscript, but only under certain
  14.   conditions described in the License.  Among other things, the License
  15.   requires that the copyright notice and this notice be preserved on all
  16.   copies.
  17. */
  18.  
  19. /*$Id: gdevdcrd.c,v 1.2 2000/09/19 19:00:12 lpd Exp $ */
  20. /* Create a sample device CRD */
  21. #include "math_.h"
  22. #include "memory_.h"
  23. #include "string_.h"
  24. #include "gx.h"
  25. #include "gserrors.h"
  26. #include "gsparam.h"
  27. #include "gscspace.h"        /* for gscie.h */
  28. #include "gscrd.h"
  29. #include "gscrdp.h"
  30. #include "gxdevcli.h"
  31. #include "gdevdcrd.h"
  32.  
  33. /*
  34.  * The parameters in this driver CRD are the default PostScript values,
  35.  * except for the optional 'dented' procedures.
  36.  */
  37. #define DENT(v, f)\
  38.   (v <= 0.5 ? v * f : (v - 0.5) * (1 - (0.5 * f)) / 0.5 + 0.5 * f)
  39. private const gs_vector3 bit_WhitePoint = {0.9505, 1, 1.0890};
  40. private const gs_range3 bit_RangePQR = {
  41.     {{0, 0.9505}, {0, 1}, {0, 1.0890}}
  42. };
  43. private const float dent_PQR = 1.0;
  44. private int
  45. bit_TransformPQR_proc(int index, floatp in, const gs_cie_wbsd * pwbsd,
  46.               gs_cie_render * pcrd, float *out)
  47. {
  48.     *out = DENT(in, dent_PQR);
  49.     return 0;
  50. }
  51. private const gs_cie_transform_proc3 bit_TransformPQR = {
  52.     bit_TransformPQR_proc, "bitTPQRDefault", {0, 0}, 0
  53. };
  54. private const float dent_LMN = 1.0;
  55. private float
  56. bit_EncodeLMN_proc(floatp in, const gs_cie_render * pcrd)
  57. {
  58.     return DENT(in, dent_LMN);
  59. }
  60. private const gs_cie_render_proc3 bit_EncodeLMN = { /* dummy */
  61.     {bit_EncodeLMN_proc, bit_EncodeLMN_proc, bit_EncodeLMN_proc}
  62. };
  63. private const gs_range3 bit_RangeLMN = {
  64.     {{0, 0.9505}, {0, 1}, {0, 1.0890}}
  65. };
  66. private const gs_matrix3 bit_MatrixABC = {
  67.     { 3.24063, -0.96893,  0.05571},
  68.     {-1.53721,  1.87576, -0.20402},
  69.     {-0.49863,  0.04152,  1.05700}
  70. };
  71. private float
  72. bit_EncodeABC_proc(floatp in, const gs_cie_render * pcrd)
  73. {
  74.     return pow(max(in, 0.0), 0.45);
  75. }
  76. private const gs_cie_render_proc3 bit_EncodeABC = {
  77.     {bit_EncodeABC_proc, bit_EncodeABC_proc, bit_EncodeABC_proc}
  78. };
  79. /* These RenderTables are no-ops. */
  80. private const byte bit_rtt0[2*2*3] = {
  81.     /*0,0,0*/ 0,0,0,
  82.     /*0,0,1*/ 0,0,255,
  83.     /*0,1,0*/ 0,255,0,
  84.     /*0,1,1*/ 0,255,255
  85. };
  86. private const byte bit_rtt1[2*2*3] = {
  87.     /*1,0,0*/ 255,0,0,
  88.     /*1,0,1*/ 255,0,255,
  89.     /*1,1,0*/ 255,255,0,
  90.     /*1,1,1*/ 255,255,255
  91. };
  92. private const gs_const_string bit_rt_data[2] = {
  93.     {bit_rtt0, 2*2*3}, {bit_rtt1, 2*2*3}
  94. };
  95. private frac
  96. bit_rt_proc(byte in, const gs_cie_render *pcrd)
  97. {
  98.     return frac_1 * in / 255;
  99. }
  100. private const gs_cie_render_table_t bit_RenderTable = {    /* dummy */
  101.     {3, {2, 2, 2}, 3, bit_rt_data},
  102.     {{bit_rt_proc, bit_rt_proc, bit_rt_proc}}
  103. };
  104.  
  105. /*
  106.  * Implement get_params for a sample device CRD.  A useful convention,
  107.  * for devices that can provide more than one CRD, is to have a settable
  108.  * parameter CRDName, which gives the name of the CRD in use.  This sample
  109.  * code provides a constant CRDName: making it settable is left as an
  110.  * exercise to the reader.
  111.  */
  112. int
  113. sample_device_crd_get_params(gx_device *pdev, gs_param_list *plist,
  114.                  const char *crd_param_name)
  115. {
  116.     int ecode = 0;
  117.  
  118.     if (param_requested(plist, "CRDName") > 0) {
  119.     gs_param_string cns;
  120.     int code;
  121.  
  122.     cns.data = (const byte *)crd_param_name;
  123.     cns.size = strlen(crd_param_name);
  124.     cns.persistent = true;
  125.     code = param_write_string(plist, "CRDName", &cns);
  126.     if (code < 0)
  127.         ecode = code;
  128.     }
  129.     if (param_requested(plist, crd_param_name) > 0) {
  130.     gs_cie_render *pcrd;
  131.     int code = gs_cie_render1_build(&pcrd, pdev->memory,
  132.                     "sample_device_crd_get_params");
  133.     if (code >= 0) {
  134.         gs_cie_transform_proc3 tpqr;
  135.  
  136.         tpqr = bit_TransformPQR;
  137.         tpqr.driver_name = pdev->dname;
  138.         code = gs_cie_render1_initialize(pcrd, NULL,
  139.             &bit_WhitePoint, NULL /*BlackPoint*/,
  140.             NULL /*MatrixPQR*/, &bit_RangePQR, &tpqr,
  141.             NULL /*MatrixLMN*/, &bit_EncodeLMN, &bit_RangeLMN,
  142.             &bit_MatrixABC, &bit_EncodeABC, NULL /*RangeABC*/,
  143.             &bit_RenderTable);
  144.         if (code >= 0) {
  145.         code = param_write_cie_render1(plist, crd_param_name, pcrd,
  146.                            pdev->memory);
  147.         }
  148.         rc_decrement(pcrd, "sample_device_crd_get_params"); /* release */
  149.     }
  150.     if (code < 0)
  151.         ecode = code;
  152.     }
  153.     if (param_requested(plist, bit_TransformPQR.proc_name) > 0) {
  154.     /*
  155.      * We definitely do not recommend the following use of a static
  156.      * to hold the address: this is a shortcut.
  157.      */
  158.     gs_cie_transform_proc my_proc = bit_TransformPQR_proc;
  159.     byte *my_addr = gs_alloc_string(pdev->memory, sizeof(my_proc),
  160.                     "sd_crd_get_params(proc)");
  161.     int code;
  162.  
  163.     if (my_addr == 0)
  164.         code = gs_note_error(gs_error_VMerror);
  165.     else {
  166.         gs_param_string as;
  167.  
  168.         memcpy(my_addr, &my_proc, sizeof(my_proc));
  169.         as.data = my_addr;
  170.         as.size = sizeof(my_proc);
  171.         as.persistent = true;
  172.         code = param_write_string(plist, bit_TransformPQR.proc_name, &as);
  173.     }
  174.     if (code < 0)
  175.         ecode = code;
  176.     }
  177.     return ecode;
  178. }
  179.